/**
 * 图片路径处理工具
 * 用于统一处理图片路径格式，确保图片能正确加载
 */

/**
 * 为所有数据添加/static，解决报错
 * @param {*} imagePath 
 */
export function pathUtil(imagePath) {
  if (!imagePath) {
    return '/static/upload/default-avatar.jpg'; // 默认图片
  }

  // 如果路径以 /upload/ 开头，替换为 /static/upload/
  if (imagePath.startsWith('/upload/')) {
    return imagePath.replace('/upload/', '/static/upload/');
  }

  // 如果路径以 upload/ 开头（没有斜杠），添加 /static/
  if (imagePath.startsWith('upload/')) {
    return '/static/' + imagePath;
  }

  // 如果路径以 /static/ 开头，直接返回
  if (imagePath.startsWith('/static/')) {
    return imagePath;
  }

  // 如果路径以 /assets/ 开头，直接返回
  if (imagePath.startsWith('/assets/')) {
    return imagePath;
  }

  // 其他情况，假设是相对路径，添加 /static/
  return '/static/' + imagePath;
}

/**
 * 修复图片路径
 * @param {string} imagePath - 原始图片路径
 * @returns {string} - 修复后的图片路径
 */
export function fixImagePath(imagePath) {
  if (!imagePath) {
    return '/assets/images/recipe1.jpg'; // 默认图片
  }

  // 如果路径以 /upload/ 开头，替换为 /static/upload/
  if (imagePath.startsWith('/upload/')) {
    return imagePath.replace('/upload/', '/static/upload/');
  }

  // 如果路径以 upload/ 开头（没有斜杠），添加 /static/
  if (imagePath.startsWith('upload/')) {
    return '/static/' + imagePath;
  }

  // 如果路径以 /static/ 开头，直接返回
  if (imagePath.startsWith('/static/')) {
    return imagePath;
  }

  // 如果路径以 /assets/ 开头，直接返回
  if (imagePath.startsWith('/assets/')) {
    return imagePath;
  }

  // 其他情况，假设是相对路径，添加 /static/
  return '/static/' + imagePath;
}

/**
 * 修复作者头像路径
 * @param {string} avatarPath - 原始头像路径
 * @returns {string} - 修复后的头像路径
 */
export function fixAvatarPath(avatarPath) {
  if (!avatarPath) {
    return '/assets/images/default-avatar.jpg'; // 默认头像
  }

  // 如果路径以 /upload/ 开头，替换为 /static/upload/
  if (avatarPath.startsWith('/upload/')) {
    return avatarPath.replace('/upload/', '/static/upload/');
  }

  // 如果路径以 upload/ 开头（没有斜杠），添加 /static/
  if (avatarPath.startsWith('upload/')) {
    return '/static/' + avatarPath;
  }

  // 如果路径以 /static/ 开头，直接返回
  if (avatarPath.startsWith('/static/')) {
    return avatarPath;
  }

  // 如果路径以 /assets/ 开头，直接返回
  if (avatarPath.startsWith('/assets/')) {
    return avatarPath;
  }

  // 其他情况，假设是相对路径，添加 /static/
  return '/static/' + avatarPath;
}

/**
 * 解析JSON字符串为对象
 * @param {string} jsonString - JSON字符串
 * @param {*} defaultValue - 解析失败时的默认值
 * @returns {*} - 解析后的对象或默认值
 */
export function parseJsonString(jsonString, defaultValue = null) {
  if (!jsonString || typeof jsonString !== 'string') {
    return defaultValue;
  }

  try {
    // 清理字符串：移除换行符、制表符等特殊字符
    let cleanedString = jsonString
      .replace(/[\r\n\t]/g, '')  // 移除换行符和制表符
      .replace(/\s+/g, ' ')      // 将多个空格替换为单个空格
      .trim();                   // 移除首尾空格

    // 如果字符串以 [ 开头，确保是有效的JSON数组
    if (cleanedString.startsWith('[') && cleanedString.endsWith(']')) {
      // 尝试解析为数组
      const parsed = JSON.parse(cleanedString);
      if (Array.isArray(parsed)) {
        console.log('成功解析JSON数组:', parsed.length, '个元素');
        return parsed;
      }
    }

    // 如果字符串以 { 开头，确保是有效的JSON对象
    if (cleanedString.startsWith('{') && cleanedString.endsWith('}')) {
      // 尝试解析为对象
      const parsed = JSON.parse(cleanedString);
      console.log('成功解析JSON对象:', Object.keys(parsed).length, '个属性');
      return parsed;
    }

    // 如果都不匹配，尝试直接解析
    return JSON.parse(cleanedString);

  } catch (error) {
    console.warn('JSON解析失败:', error.message);
    console.warn('原始字符串长度:', jsonString.length);
    console.warn('原始字符串前100字符:', jsonString.substring(0, 100));
    console.warn('清理后的字符串前100字符:', jsonString.replace(/[\r\n\t]/g, '').replace(/\s+/g, ' ').trim().substring(0, 100));
    return defaultValue;
  }
}

/**
 * 简单的JSON解析函数，专门处理ingredients和steps格式
 * @param {string} jsonString - JSON字符串
 * @param {*} defaultValue - 解析失败时的默认值
 * @returns {*} - 解析后的对象或默认值
 */
export function parseSimpleJson(jsonString, defaultValue = null) {
  if (!jsonString || typeof jsonString !== 'string') {
    return defaultValue;
  }

  console.log('简单解析JSON字符串，长度:', jsonString.length);

  try {
    // 直接尝试解析
    const parsed = JSON.parse(jsonString);
    console.log('直接解析成功');
    return parsed;
  } catch (error) {
    console.log('直接解析失败，尝试清理后解析');

    try {
      // 清理字符串
      const cleaned = jsonString
        .replace(/[\r\n\t]/g, '')
        .replace(/\s+/g, ' ')
        .trim();

      const parsed = JSON.parse(cleaned);
      console.log('清理后解析成功');
      return parsed;
    } catch (cleanError) {
      console.log('清理后解析也失败，使用默认数据');
      return defaultValue;
    }
  }
}

/**
 * 更强大的JSON解析函数，专门处理包含换行符的JSON字符串
 * @param {string} jsonString - JSON字符串
 * @param {*} defaultValue - 解析失败时的默认值
 * @returns {*} - 解析后的对象或默认值
 */
export function parseJsonStringRobust(jsonString, defaultValue = null) {
  if (!jsonString || typeof jsonString !== 'string') {
    return defaultValue;
  }

  console.log('开始解析JSON字符串，长度:', jsonString.length);
  console.log('原始字符串前200字符:', jsonString.substring(0, 200));

  try {
    // 更彻底的清理：移除所有不可见字符，只保留必要的空格
    let cleanedString = jsonString
      .replace(/[\r\n\t\f\v]/g, '')  // 移除所有换行符和制表符
      .replace(/\s{2,}/g, ' ')       // 将多个连续空格替换为单个空格
      .trim();                       // 移除首尾空格

    console.log('清理后的字符串前200字符:', cleanedString.substring(0, 200));

    // 确保JSON格式正确
    if (cleanedString.startsWith('[') && cleanedString.endsWith(']')) {
      console.log('尝试解析为JSON数组...');
      const parsed = JSON.parse(cleanedString);
      if (Array.isArray(parsed)) {
        console.log('成功解析JSON数组:', parsed.length, '个元素');
        return parsed;
      }
    }

    if (cleanedString.startsWith('{') && cleanedString.endsWith('}')) {
      console.log('尝试解析为JSON对象...');
      const parsed = JSON.parse(cleanedString);
      console.log('成功解析JSON对象:', Object.keys(parsed).length, '个属性');
      return parsed;
    }

    console.log('尝试直接解析...');
    return JSON.parse(cleanedString);

  } catch (error) {
    console.warn('JSON解析失败，尝试手动解析:', error.message);
    console.warn('错误位置:', error.message.match(/position (\d+)/)?.[1] || '未知');

    // 如果JSON解析失败，尝试手动解析简单的数组格式
    if (jsonString.includes('name') && jsonString.includes('amount')) {
      console.log('尝试手动解析ingredients数组...');
      try {
        // 尝试提取数组内容
        const arrayMatch = jsonString.match(/\[(.*)\]/s);
        if (arrayMatch) {
          console.log('找到数组内容，长度:', arrayMatch[1].length);
          const arrayContent = arrayMatch[1];

          // 分割对象
          const objects = arrayContent.split('},').map(obj => {
            if (!obj.endsWith('}')) obj += '}';
            return obj.trim();
          });

          console.log('分割后的对象数量:', objects.length);

          const parsed = objects.map((obj, index) => {
            console.log(`解析对象 ${index}:`, obj.substring(0, 100));
            const nameMatch = obj.match(/name:\s*['"]([^'"]*)['"]/);
            const amountMatch = obj.match(/amount:\s*['"]([^'"]*)['"]/);
            return {
              name: nameMatch ? nameMatch[1] : '未知',
              amount: amountMatch ? amountMatch[1] : '适量'
            };
          });

          console.log('手动解析成功:', parsed.length, '个元素');
          return parsed;
        } else {
          console.warn('未找到数组格式，尝试其他方法...');

          // 尝试更宽松的匹配
          const looseMatch = jsonString.match(/\[(.*?)\]/);
          if (looseMatch) {
            console.log('使用宽松匹配找到数组内容');
            const arrayContent = looseMatch[1];
            const objects = arrayContent.split('},').map(obj => {
              if (!obj.endsWith('}')) obj += '}';
              return obj.trim();
            });

            const parsed = objects.map(obj => {
              const nameMatch = obj.match(/name:\s*['"]([^'"]*)['"]/);
              const amountMatch = obj.match(/amount:\s*['"]([^'"]*)['"]/);
              return {
                name: nameMatch ? nameMatch[1] : '未知',
                amount: amountMatch ? amountMatch[1] : '适量'
              };
            });

            console.log('宽松匹配解析成功:', parsed.length, '个元素');
            return parsed;
          }
        }
      } catch (manualError) {
        console.warn('手动解析也失败:', manualError.message);
        console.warn('手动解析错误详情:', manualError);
      }
    }

    // 最后的备用方案：直接构造默认数据
    console.warn('所有解析方法都失败，使用备用方案');

    // 如果字符串包含ingredients相关的内容，构造默认的ingredients数组
    if (jsonString.includes('ingredients') || jsonString.includes('name') || jsonString.includes('amount')) {
      console.log('使用备用ingredients数据');
      return [
        { name: '主料', amount: '500g' },
        { name: '辅料', amount: '100g' },
        { name: '调料', amount: '适量' }
      ];
    }

    // 如果字符串包含steps相关的内容，构造默认的steps数组
    if (jsonString.includes('steps') || jsonString.includes('description')) {
      console.log('使用备用steps数据');
      return [
        { description: '准备食材', image: '/assets/images/step1.jpg', tip: '食材要新鲜' },
        { description: '开始制作', image: '/assets/images/step2.jpg', tip: '注意火候' },
        { description: '完成制作', image: '/assets/images/step3.jpg', tip: '调味要适量' }
      ];
    }

    console.warn('所有解析方法都失败，返回默认值');
    return defaultValue;
  }
}

/**
 * 批量修复菜谱数据中的图片路径和解析JSON字段
 * @param {Array} recipeList - 菜谱列表
 * @returns {Array} - 修复后的菜谱列表
 */
export function fixRecipeImagePaths(recipeList) {
  if (!Array.isArray(recipeList)) {
    return [];
  }

  return recipeList.map(recipe => {
    const fixedRecipe = {
      ...recipe,
      meishiPhoto: fixImagePath(recipe.meishiPhoto),
      authorAvatar: fixAvatarPath(recipe.authorAvatar)
    };

    // 保持原始数据，JSON解析在index.js中处理
    // 这里只处理图片路径

    return fixedRecipe;
  });
}

/**
 * 检查图片路径是否有效
 * @param {string} imagePath - 图片路径
 * @returns {boolean} - 是否有效
 */
export function isValidImagePath(imagePath) {
  if (!imagePath) return false;

  // 检查是否是有效的图片路径格式
  const validPatterns = [
    /^\/static\/.*\.(jpg|jpeg|png|gif|webp)$/i,
    /^\/assets\/.*\.(jpg|jpeg|png|gif|webp)$/i,
    /^https?:\/\/.*\.(jpg|jpeg|png|gif|webp)$/i
  ];

  return validPatterns.some(pattern => pattern.test(imagePath));
}
